// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Slightly adapted for inclusion in V8.
// Copyright 2016 the V8 project authors. All rights reserved.

#include "src/base/debug/stack_trace.h"

// This file can't use "src/base/win32-headers.h" because it defines symbols
// that lead to compilation errors. But `NOMINMAX` should be defined to disable
// defining of the `min` and `max` MACROS.
#ifndef NOMINMAX
#define NOMINMAX
#endif

#include <windows.h>
#include <dbghelp.h>
#include <stddef.h>

#include <iostream>
#include <memory>
#include <string>

#include "src/base/logging.h"
#include "src/base/macros.h"

inline BOOL SymGetSearchPathWXp(HANDLE process, PWSTR search_path,
    DWORD search_path_length)
{
    typedef BOOL(WINAPI * PFN_SymGetSearchPathW)(
        HANDLE process, PWSTR search_path, DWORD search_path_length);
    static PFN_SymGetSearchPathW s_SymGetSearchPathW;
    static BOOL s_is_init = FALSE;

    if (!s_is_init) {
        HMODULE shell32 = LoadLibraryW(L"Dbghelp.dll");
        s_SymGetSearchPathW = (PFN_SymGetSearchPathW)(GetProcAddress(shell32, "SymGetSearchPathW"));
        s_is_init = TRUE;
    }
    if (s_SymGetSearchPathW)
        return s_SymGetSearchPathW(process, search_path, search_path_length);

    return FALSE;
}

inline BOOL SymSetSearchPathWXp(HANDLE process, PCWSTR search_path)
{
    typedef BOOL(WINAPI * PFN_SymSetSearchPathW)(HANDLE process,
        PCWSTR search_path);
    static PFN_SymSetSearchPathW s_SymSetSearchPathW;
    static BOOL s_is_init = FALSE;

    if (!s_is_init) {
        HMODULE shell32 = LoadLibraryW(L"Dbghelp.dll");
        s_SymSetSearchPathW = (PFN_SymSetSearchPathW)(GetProcAddress(shell32, "SymSetSearchPathW"));
        s_is_init = TRUE;
    }
    if (s_SymSetSearchPathW)
        return s_SymSetSearchPathW(process, search_path);

    return FALSE;
}

namespace v8 {
namespace base {
    namespace debug {

        namespace {

            // Previous unhandled filter. Will be called if not nullptr when we intercept an
            // exception. Only used in unit tests.
            LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = nullptr;

            bool g_dump_stack_in_signal_handler = true;
            bool g_initialized_symbols = false;
            DWORD g_init_error = ERROR_SUCCESS;

            // Prints the exception call stack.
            // This is the unit tests exception filter.
            long WINAPI StackDumpExceptionFilter(EXCEPTION_POINTERS* info)
            { // NOLINT
                if (g_dump_stack_in_signal_handler) {
                    debug::StackTrace(info).Print();
                }
                if (g_previous_filter)
                    return g_previous_filter(info);
                return EXCEPTION_CONTINUE_SEARCH;
            }

            bool InitializeSymbols()
            {
                if (g_initialized_symbols)
                    return g_init_error == ERROR_SUCCESS;
                g_initialized_symbols = true;
                // Defer symbol load until they're needed, use undecorated names, and get line
                // numbers.
                SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME | SYMOPT_LOAD_LINES);
                if (!SymInitialize(GetCurrentProcess(), nullptr, TRUE)) {
                    g_init_error = GetLastError();
                    // TODO(awong): Handle error: SymInitialize can fail with
                    // ERROR_INVALID_PARAMETER.
                    // When it fails, we should not call debugbreak since it kills the current
                    // process (prevents future tests from running or kills the browser
                    // process).
                    return false;
                }

                // When transferring the binaries e.g. between bots, path put
                // into the executable will get off. To still retrieve symbols correctly,
                // add the directory of the executable to symbol search path.
                // All following errors are non-fatal.
                const size_t kSymbolsArraySize = 1024;
                std::unique_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]);

                // Note: The below function takes buffer size as number of characters,
                // not number of bytes!
                if (!SymGetSearchPathWXp(GetCurrentProcess(), symbols_path.get(), // SUPPORT_XP_CODE
                        kSymbolsArraySize)) {
                    g_init_error = GetLastError();
                    return false;
                }

                wchar_t exe_path[MAX_PATH];
                GetModuleFileName(nullptr, exe_path, MAX_PATH);
                std::wstring exe_path_wstring(exe_path);
                // To get the path without the filename, we just need to remove the final
                // slash and everything after it.
                std::wstring new_path(
                    std::wstring(symbols_path.get()) + L";" + exe_path_wstring.substr(0, exe_path_wstring.find_last_of(L"\\/")));
                if (!SymSetSearchPathWXp(GetCurrentProcess(), new_path.c_str())) { // SUPPORT_XP_CODE
                    g_init_error = GetLastError();
                    return false;
                }

                g_init_error = ERROR_SUCCESS;
                return true;
            }

            // For the given trace, attempts to resolve the symbols, and output a trace
            // to the ostream os.  The format for each line of the backtrace is:
            //
            //    <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
            //
            // This function should only be called if Init() has been called.  We do not
            // LOG(FATAL) here because this code is called might be triggered by a
            // LOG(FATAL) itself. Also, it should not be calling complex code that is
            // extensible like PathService since that can in turn fire CHECKs.
            void OutputTraceToStream(const void* const* trace, size_t count,
                std::ostream* os)
            {
                for (size_t i = 0; (i < count) && os->good(); ++i) {
                    const int kMaxNameLength = 256;
                    DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);

                    // Code adapted from MSDN example:
                    // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
                    ULONG64 buffer[(sizeof(SYMBOL_INFO) + kMaxNameLength * sizeof(wchar_t) + sizeof(ULONG64) - 1) / sizeof(ULONG64)];
                    memset(buffer, 0, sizeof(buffer));

                    // Initialize symbol information retrieval structures.
                    DWORD64 sym_displacement = 0;
                    PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]);
                    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
                    symbol->MaxNameLen = kMaxNameLength - 1;
                    BOOL has_symbol = SymFromAddr(GetCurrentProcess(), frame, &sym_displacement, symbol);

                    // Attempt to retrieve line number information.
                    DWORD line_displacement = 0;
                    IMAGEHLP_LINE64 line = {};
                    line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
                    BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame,
                        &line_displacement, &line);

                    // Output the backtrace line.
                    (*os) << "\t";
                    if (has_symbol) {
                        (*os) << symbol->Name << " [0x" << trace[i] << "+" << sym_displacement
                              << "]";
                    } else {
                        // If there is no symbol information, add a spacer.
                        (*os) << "(No symbol) [0x" << trace[i] << "]";
                    }
                    if (has_line) {
                        (*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
                    }
                    (*os) << "\n";
                }
            }

        } // namespace

        bool EnableInProcessStackDumping()
        {
            // Add stack dumping support on exception on windows. Similar to OS_POSIX
            // signal() handling in process_util_posix.cc.
            g_previous_filter = SetUnhandledExceptionFilter(&StackDumpExceptionFilter);
            g_dump_stack_in_signal_handler = true;

            // Need to initialize symbols early in the process or else this fails on
            // swarming (since symbols are in different directory than in the exes) and
            // also release x64.
            return InitializeSymbols();
        }

        void DisableSignalStackDump()
        {
            g_dump_stack_in_signal_handler = false;
        }

        StackTrace::StackTrace()
        {
            // When walking our own stack, use CaptureStackBackTrace().
            count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, nullptr);
        }

        StackTrace::StackTrace(EXCEPTION_POINTERS* exception_pointers)
        {
            InitTrace(exception_pointers->ContextRecord);
        }

        StackTrace::StackTrace(const CONTEXT* context) { InitTrace(context); }

        void StackTrace::InitTrace(const CONTEXT* context_record)
        {
            // StackWalk64 modifies the register context in place, so we have to copy it
            // so that downstream exception handlers get the right context.  The incoming
            // context may have had more register state (YMM, etc) than we need to unwind
            // the stack. Typically StackWalk64 only needs integer and control registers.
            CONTEXT context_copy;
            memcpy(&context_copy, context_record, sizeof(context_copy));
            context_copy.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;

            // When walking an exception stack, we need to use StackWalk64().
            count_ = 0;
            // Initialize stack walking.
            STACKFRAME64 stack_frame;
            memset(&stack_frame, 0, sizeof(stack_frame));
#if defined(_WIN64)
#if defined(_M_X64)
            int machine_type = IMAGE_FILE_MACHINE_AMD64;
            stack_frame.AddrPC.Offset = context_record->Rip;
            stack_frame.AddrFrame.Offset = context_record->Rbp;
            stack_frame.AddrStack.Offset = context_record->Rsp;
#elif defined(_M_ARM64)
            int machine_type = IMAGE_FILE_MACHINE_ARM64;
            stack_frame.AddrPC.Offset = context_record->Pc;
            stack_frame.AddrFrame.Offset = context_record->Fp;
            stack_frame.AddrStack.Offset = context_record->Sp;
#else
#error Unsupported Arch
#endif
#else
            int machine_type = IMAGE_FILE_MACHINE_I386;
            stack_frame.AddrPC.Offset = context_record->Eip;
            stack_frame.AddrFrame.Offset = context_record->Ebp;
            stack_frame.AddrStack.Offset = context_record->Esp;
#endif
            stack_frame.AddrPC.Mode = AddrModeFlat;
            stack_frame.AddrFrame.Mode = AddrModeFlat;
            stack_frame.AddrStack.Mode = AddrModeFlat;
            while (StackWalk64(machine_type, GetCurrentProcess(), GetCurrentThread(),
                       &stack_frame, &context_copy, nullptr,
                       &SymFunctionTableAccess64, &SymGetModuleBase64, nullptr)
                && count_ < arraysize(trace_)) {
                trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset);
            }

            for (size_t i = count_; i < arraysize(trace_); ++i)
                trace_[i] = nullptr;
        }

        void StackTrace::Print() const { OutputToStream(&std::cerr); }

        void StackTrace::OutputToStream(std::ostream* os) const
        {
            InitializeSymbols();
            if (g_init_error != ERROR_SUCCESS) {
                (*os) << "Error initializing symbols (" << g_init_error
                      << ").  Dumping unresolved backtrace:\n";
                for (size_t i = 0; (i < count_) && os->good(); ++i) {
                    (*os) << "\t" << trace_[i] << "\n";
                }
            } else {
                (*os) << "\n";
                (*os) << "==== C stack trace ===============================\n";
                (*os) << "\n";
                OutputTraceToStream(trace_, count_, os);
            }
        }

    } // namespace debug
} // namespace base
} // namespace v8
